home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / examples / mbox.c < prev    next >
C/C++ Source or Header  |  1997-07-22  |  13KB  |  689 lines
  1.  
  2. static char rcsid[] =
  3.     "$Id: mbox.c,v 1.7 1997/07/09 13:25:10 pvmsrc Exp $";
  4.  
  5. /*
  6.  *         PVM version 3.4:  Parallel Virtual Machine System
  7.  *               University of Tennessee, Knoxville TN.
  8.  *           Oak Ridge National Laboratory, Oak Ridge TN.
  9.  *                   Emory University, Atlanta GA.
  10.  *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
  11.  *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
  12.  *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
  13.  *                   (C) 1997 All Rights Reserved
  14.  *
  15.  *                              NOTICE
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and
  18.  * its documentation for any purpose and without fee is hereby granted
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both the copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  *
  23.  * Neither the Institutions (Emory University, Oak Ridge National
  24.  * Laboratory, and University of Tennessee) nor the Authors make any
  25.  * representations about the suitability of this software for any
  26.  * purpose.  This software is provided ``as is'' without express or
  27.  * implied warranty.
  28.  *
  29.  * PVM version 3 was funded in part by the U.S. Department of Energy,
  30.  * the National Science Foundation and the State of Tennessee.
  31.  */
  32.  
  33. /*********************************************************************
  34.  
  35.    mbox - PVM 3.4 Message Mailbox Test Program
  36.  
  37.    author:  James Arthur Kohl
  38.             Oak Ridge National Laboratory
  39.             March, 1997.
  40.  
  41. **********************************************************************/
  42.  
  43. /*********************************************************************
  44.  
  45.   PVM 3.4 Message Mailbox Tests:
  46.   ------------------------------
  47.  
  48.   All tests to be run, in order, on a single host VM, on the master
  49.   host of 2+ host VM, and on the slave host of 2+ host VM.
  50.  
  51.   An '*' marking indicates that, for multiple host VMs, the marked
  52.   task should be spawned on a different host than the other non-marked
  53.   tasks.
  54.  
  55.   Tests are of the form:
  56.         ( test invocation ) -> expected status returned
  57.  
  58.   1.    ( mbox ) -> 1
  59.  
  60.   2.  * ( mbox query ) -> 0
  61.  
  62.   3.    ( mbox sleep=3 & ) -> 1
  63.       * ( mbox query 0 ) -> 1
  64.       * ( mbox query ) -> 1
  65.  
  66.   4.  * ( mbox query ) -> 0
  67.  
  68.   5.    ( mbox sleep=3 & ) -> 1
  69.       * ( mbox query 0 ) -> 1
  70.       * ( mbox query ) -> 1
  71.         ( mbox sleep=3 & ) -> 1
  72.       * ( mbox query 0 ) -> 1
  73.       * ( mbox query ) -> 1
  74.   
  75.   6.  * ( mbox query ) -> 0
  76.   
  77.   7.    ( mbox sleep=3 & ) -> 1
  78.         ( mbox excl ) -> 0
  79.   
  80.   8.  * ( mbox query ) -> 0
  81.   
  82.   9.    ( mbox sleep=3 & ) -> 1
  83.         ( mbox favail ) -> 1
  84.       * ( mbox query ) -> 0
  85.   
  86.   10.   ( mbox sleep=3 & ) -> 1
  87.         ( mbox favail excl ) -> 1
  88.       * ( mbox query 0 ) -> 1
  89.       * ( mbox query 1 ) -> 0
  90.       * ( mbox query ) -> 1
  91.   
  92.   11. * ( mbox query ) -> 0
  93.   
  94.   12.   ( mbox sleep=3 & ) -> 1
  95.         ( mbox sleep=3 favail excl & ) -> 1
  96.       * ( mbox query 0 ) -> 1
  97.       * ( mbox query 1 ) -> 1
  98.       * ( mbox query ) -> 2
  99.   
  100.   13. * ( mbox query ) -> 0
  101.   
  102.   14.   ( mbox sleep=3 lock & ) -> 1
  103.       * ( mbox query 0 ) -> 1
  104.       * ( mbox query ) -> 1
  105.         ( mbox ) -> 0
  106.         ( mbox lock ) -> 0
  107.         ( mbox excl ) -> 0
  108.         ( mbox lock excl ) -> 0
  109.         ( mbox delete 0 ) -> 0
  110.         ( mbox favail ) -> 1
  111.       * ( mbox query 0 ) -> 1
  112.       * ( mbox query 1 ) -> 0
  113.       * ( mbox query ) -> 1
  114.   
  115.   15.   ( mbox query ) -> 0
  116.   
  117.   16.   ( mbox sleep=3 lock & ) -> 1
  118.         ( mbox sleep=3 favail & ) -> 1
  119.       * ( mbox query 0 ) -> 1
  120.       * ( mbox query 1 ) -> 1
  121.       * ( mbox query ) -> 2
  122.         ( mbox favail ) -> 1
  123.       * ( mbox query 0 ) -> 1
  124.       * ( mbox query 1 ) -> 0
  125.       * ( mbox query ) -> 1
  126.   
  127.   17.   ( mbox query ) -> 0
  128.   
  129.   18.   ( mbox sleep=3 lock & ) -> 1
  130.         ( mbox sleep=3 favail & ) -> 1
  131.       * ( mbox query 0 ) -> 1
  132.       * ( mbox query 1 ) -> 1
  133.       * ( mbox query ) -> 2
  134.         ( mbox favail excl ) -> 1
  135.       * ( mbox query 0 ) -> 1
  136.       * ( mbox query 1 ) -> 1
  137.       * ( mbox query ) -> 2
  138.   
  139.   19.   ( mbox query ) -> 0
  140.   
  141.   20.   ( mbox pers ) -> 1
  142.       * ( mbox query 0 ) -> 1
  143.       * ( mbox query ) -> 1
  144.         ( mbox delete 0 ) -> 1
  145.       * ( mbox query ) -> 0
  146.   
  147.   21.   ( mbox pers lock ) -> 1
  148.       * ( mbox query 0 ) -> 1
  149.       * ( mbox query ) -> 1
  150.         ( mbox delete 0 ) -> 1
  151.       * ( mbox query ) -> 0
  152.   
  153.   22.   ( mbox pers ) -> 1
  154.       * ( mbox delete 0 ) -> 1
  155.   
  156.   23.   ( mbox pers ) -> 1
  157.         ( mbox pers favail ) -> 1
  158.       * ( mbox query 0 ) -> 1
  159.       * ( mbox query 1 ) -> 0
  160.       * ( mbox query ) -> 1
  161.         ( mbox delete 0 ) -> 1
  162.   
  163.   24.   ( mbox pers ) -> 1
  164.         ( mbox pers excl ) -> 0
  165.         ( mbox pers favail excl ) -> 1
  166.         ( mbox pers favail excl ) -> 1
  167.       * ( mbox query 0 ) -> 1
  168.       * ( mbox query 1 ) -> 1
  169.       * ( mbox query 2 ) -> 1
  170.       * ( mbox query ) -> 3
  171.         ( mbox delete ) -> 3
  172.   
  173.   25.   ( mbox sleep=10 noreset & ) -> 1
  174.         ( ... do pvm reset ... )
  175.         ( mbox query 0 ) -> 1
  176.   
  177.   26.   ( mbox delete ) -> 0
  178.   
  179.   27.   ( mbox noexit ) -> 1
  180.       * ( mbox query ) -> 0
  181.  
  182. **********************************************************************/
  183.   
  184. #include <stdio.h>
  185. #include <string.h>
  186. #include "pvm3.h"
  187.  
  188. #ifdef WIN32
  189. #define sleep(a) Sleep(a)
  190. #endif
  191.  
  192. #define MBOX_CLASS    "mbox_test"
  193.  
  194. int mytid;
  195.  
  196. main( argc, argv )
  197. int argc;
  198. char *argv[];
  199. {
  200.     char CLASS_NAME[255];
  201.  
  202.     struct pvmmboxinfo *classes;
  203.     int nclasses;
  204.  
  205.     char pattern[255];
  206.  
  207.     char *cmds[100];
  208.     int ncmds;
  209.  
  210.     char bufout[255];
  211.     char bufin[255];
  212.  
  213.     int do_noreset;
  214.     int do_favail;
  215.     int do_unpack;
  216.     int do_minst;
  217.     int do_owrit;
  218.     int do_rddel;
  219.     int do_sleep;
  220.     int do_exit;
  221.     int do_pers;
  222.     int do_wait;
  223.  
  224.     int index;
  225.     int flags;
  226.     int done;
  227.     int i, j;
  228.     int ret;
  229.     int tmp;
  230.     int cc;
  231.  
  232.     /* Parse Command Line */
  233.  
  234.     strcpy( CLASS_NAME, MBOX_CLASS );
  235.  
  236.     do_noreset = 0;
  237.     do_favail = 0;
  238.     do_unpack = 1;
  239.     do_minst = 0;
  240.     do_owrit = 0;
  241.     do_rddel = 0;
  242.     do_sleep = 0;
  243.     do_exit = 1;
  244.     do_pers = 0;
  245.     do_wait = 0;
  246.  
  247.     ncmds = 0;
  248.  
  249.     for ( i=1 ; i < argc ; i++ )
  250.     {
  251.         if ( !strcmp( argv[i], "pers" ) )
  252.             do_pers++;
  253.  
  254.         else if ( !strcmp( argv[i], "favail" ) )
  255.             do_favail++;
  256.  
  257.         else if ( !strcmp( argv[i], "sleep" ) )
  258.             do_sleep = 10;
  259.  
  260.         else if ( !strncmp( argv[i], "sleep=", 6 ) )
  261.             sscanf( (argv[i]) + 6, "%d", &do_sleep );
  262.  
  263.         else if ( !strcmp( argv[i], "owrit" ) )
  264.             do_owrit++;
  265.  
  266.         else if ( !strcmp( argv[i], "minst" ) )
  267.             do_minst++;
  268.  
  269.         else if ( !strcmp( argv[i], "rddel" ) )
  270.             do_rddel++;
  271.  
  272.         else if ( !strcmp( argv[i], "wait" ) )
  273.             do_wait++;
  274.  
  275.         else if ( !strcmp( argv[i], "noexit" ) )
  276.             do_exit = 0;
  277.  
  278.         else if ( !strcmp( argv[i], "noreset" ) )
  279.             do_noreset = 1;
  280.  
  281.         else if ( !strncmp( argv[i], "name=", 5 ) )
  282.         {
  283.             strcpy( CLASS_NAME, (argv[i]) + 5 );
  284.             do_unpack = 0;
  285.         }
  286.  
  287.         else if ( !strcmp( argv[i], "help" ) )
  288.             usage();
  289.  
  290.         else
  291.             cmds[ ncmds++ ] = argv[i];
  292.     }
  293.  
  294.     /* Enter PVM */
  295.  
  296.     mytid = pvm_mytid();
  297.  
  298.     if ( mytid < 0 )
  299.     {
  300.         printf( "*** Could not connect to PVM...  Exiting... ***\n" );
  301.  
  302.         exit( -1 );
  303.     }
  304.     
  305.     else
  306.         printf( "mbox started as tid=0x%x\n", mytid );
  307.  
  308.     ret = 0;
  309.  
  310.     if ( do_noreset )
  311.         pvm_setopt( PvmNoReset, 1 );
  312.  
  313.     /* Do Basic Stuff & Check */
  314.  
  315.     if ( !ncmds )
  316.     {
  317.         strcpy( bufin, "This Message Left Here By Mbox" );
  318.  
  319.         set_flags( &flags, do_pers, do_favail, do_owrit, do_minst,
  320.             do_rddel, do_wait );
  321.  
  322.         index = stuff_msg( CLASS_NAME, flags, bufin, mytid );
  323.  
  324.         if ( index < 0 )
  325.             exit( -1 );
  326.  
  327.         cc = check_msg( CLASS_NAME, index, 0, bufout, &tmp, do_unpack );
  328.  
  329.         if ( cc < 0 )
  330.             exit( -1 );
  331.         
  332.         if ( strcmp( bufout, bufin ) )
  333.         {
  334.             printf( "String Mismatch Error:  \"%s\"  !=  \"%s\"\n",
  335.                 bufout, bufin );
  336.         }
  337.  
  338.         else if ( tmp != mytid )
  339.         {
  340.             printf( "Number Mismatch Error:  %d  !=  %d\n",
  341.                 tmp, mytid );
  342.         }
  343.  
  344.         else
  345.         {
  346.             printf( "Retrieved Message is a Match.\n" );
  347.  
  348.             ret++;
  349.         }
  350.  
  351.         if ( do_sleep )
  352.             sleep( do_sleep );
  353.     }
  354.  
  355.     /* Execute Commands */
  356.  
  357.     else
  358.     {
  359.         if ( !strcmp( cmds[0], "query" ) )
  360.         {
  361.             set_flags( &flags, do_pers, do_favail, do_owrit, do_minst,
  362.                 do_rddel, do_wait );
  363.  
  364.             if ( ncmds == 1 )
  365.             {
  366.                 for ( i=0 ; i < 10 ; i++ )
  367.                 {
  368.                     cc = check_msg( CLASS_NAME, i, flags,
  369.                         bufout, &tmp, do_unpack );
  370.  
  371.                     if ( cc < 0 )
  372.                         printf( "No Message at Index=%d\n", i );
  373.  
  374.                     else
  375.                     {
  376.                         printf( "Message at Index=%d:  \"%s\"  0x%x\n",
  377.                             i, bufout, tmp );
  378.  
  379.                         ret++;
  380.                     }
  381.                 }
  382.             }
  383.  
  384.             else
  385.             {
  386.                 index = atoi( cmds[1] );
  387.  
  388.                 cc = check_msg( CLASS_NAME, index, flags,
  389.                     bufout, &tmp, do_unpack );
  390.  
  391.                  if ( cc < 0 )
  392.                     printf( "No Message at Index=%d\n", index );
  393.  
  394.                 else
  395.                 {
  396.                     printf( "Message at Index=%d:  \"%s\"  0x%x\n",
  397.                         index, bufout, tmp );
  398.  
  399.                     ret++;
  400.                 }
  401.             }
  402.         }
  403.  
  404.         else if ( !strcmp( cmds[0], "delete" ) )
  405.         {
  406.             set_flags( &flags, do_pers, do_favail, do_owrit, do_minst,
  407.                 do_rddel, do_wait );
  408.  
  409.             if ( ncmds == 1 )
  410.             {
  411.                 for ( i=0 ; i < 10 ; i++ )
  412.                 {
  413.                     cc = pvm_delinfo( CLASS_NAME, i, flags );
  414.  
  415.                     if ( cc < 0 )
  416.                     {
  417.                         printf( "No Message to Delete at Index=%d\n",
  418.                             i );
  419.                     }
  420.  
  421.                     else
  422.                     {
  423.                         printf( "Message at Index=%d Deleted.\n", i );
  424.  
  425.                         ret++;
  426.                     }
  427.                 }
  428.             }
  429.  
  430.             else
  431.             {
  432.                 index = atoi( cmds[1] );
  433.  
  434.                 cc = pvm_delinfo( CLASS_NAME, index, flags );
  435.  
  436.                 if ( cc < 0 )
  437.                 {
  438.                     printf( "No Message to Delete at Index=%d\n",
  439.                         index );
  440.                 }
  441.  
  442.                 else
  443.                 {
  444.                     printf( "Message at Index=%d Deleted.\n", index );
  445.  
  446.                     ret++;
  447.                 }
  448.             }
  449.         }
  450.  
  451.         else if ( !strcmp( cmds[0], "querynoreset" ) )
  452.         {
  453.             done = 0;
  454.             i = 0;
  455.  
  456.             while ( !done )
  457.             {
  458.                 cc = check_msg( PVMNORESETCLASS, i, PvmMboxFirstAvail,
  459.                     bufout, &tmp, 0 );
  460.  
  461.                 if ( cc < 0 )
  462.                     done++;
  463.  
  464.                 else
  465.                 {
  466.                     pvm_upkint( &tmp, 1, 1 );
  467.  
  468.                     printf( "NoReset Message at Index=%d:  0x%x\n",
  469.                         i, tmp );
  470.  
  471.                     ret++;
  472.  
  473.                     i++;
  474.                 }
  475.             }
  476.         }
  477.  
  478.         else if ( !strcmp( cmds[0], "spawn" ) )
  479.         {
  480.             pvm_spawn( "mbox", argv + 2,
  481.                 PvmTaskHost | PvmHostCompl, ".", 1, &cc );
  482.  
  483.             if ( cc < 0 )
  484.                 pvm_perror( "Spawning on Other Host" );
  485.             
  486.             else
  487.             {
  488.                 pvm_notify( PvmTaskExit, 100, 1, &cc );
  489.  
  490.                 pvm_recv( -1, 100 );
  491.             }
  492.         }
  493.  
  494.         else if ( !strcmp( cmds[0], "info" ) )
  495.         {
  496.             if ( ncmds == 1 )
  497.                 strcpy( pattern, "*" );
  498.             
  499.             else
  500.                 strcpy( pattern, cmds[1] );
  501.  
  502.             if ( (cc = pvm_getmboxinfo( pattern, &nclasses, &classes ))
  503.                     < 0 )
  504.                 pvm_perror( "Querying Mbox Info" );
  505.             
  506.             else
  507.             {
  508.                 for ( i=0 ; i < nclasses ; i++ )
  509.                 {
  510.                     printf( "Class \"%s\" has %d entries:\n",
  511.                         classes[i].mi_name, classes[i].mi_nentries );
  512.                     
  513.                     for ( j=0 ; j < classes[i].mi_nentries ; j++ )
  514.                     {
  515.                         printf( "\tindex=%d owner=0x%x/%d flags=0x%x\n",
  516.                             classes[i].mi_indices[j],
  517.                             classes[i].mi_owners[j],
  518.                             classes[i].mi_owners[j],
  519.                             classes[i].mi_flags[j] );
  520.                     }
  521.  
  522.                     printf( "\n" );
  523.                 }
  524.             }
  525.         }
  526.     }
  527.  
  528.     if ( do_exit )
  529.         pvm_exit();
  530.  
  531.     exit( ret );
  532. }
  533.  
  534.  
  535. int
  536. set_flags( flags,
  537.     do_pers, do_favail, do_owrit, do_minst, do_rddel, do_wait )
  538. int *flags;
  539. int do_pers;
  540. int do_favail;
  541. int do_owrit;
  542. int do_minst;
  543. int do_rddel;
  544. int do_wait;
  545. {
  546.     *flags = PvmMboxDefault;
  547.  
  548.     if ( do_pers )
  549.         *flags |= PvmMboxPersistent;
  550.  
  551.     if ( do_favail )
  552.         *flags |= PvmMboxFirstAvail;
  553.  
  554.     if ( do_owrit )
  555.         *flags |= PvmMboxOverWritable;
  556.  
  557.     if ( do_minst )
  558.         *flags |= PvmMboxMultiInstance;
  559.  
  560.     if ( do_rddel )
  561.         *flags |= PvmMboxReadAndDelete;
  562.  
  563.     if ( do_wait )
  564.         *flags |= PvmMboxWaitForInfo;
  565. }
  566.  
  567.  
  568. int
  569. dump_flags( flags )
  570. int flags;
  571. {
  572.     if ( flags & PvmMboxPersistent )
  573.         printf( " PERSISTENT" );
  574.  
  575.     if ( flags & PvmMboxFirstAvail )
  576.         printf( " FIRST_AVAIL" );
  577.  
  578.     if ( flags & PvmMboxOverWritable )
  579.         printf( " OVER_WRITABLE" );
  580.  
  581.     if ( flags & PvmMboxMultiInstance )
  582.         printf( " MULTI_INSTANCE" );
  583.  
  584.     if ( flags & PvmMboxReadAndDelete )
  585.         printf( " READ_AND_DELETE" );
  586. }
  587.  
  588.  
  589. int
  590. stuff_msg( class, flags, str, num )
  591. char *class;
  592. int flags;
  593. char *str;
  594. int num;
  595. {
  596.     int cc;
  597.  
  598.     /* Create Message */
  599.  
  600.     pvm_initsend( PvmDataDefault );
  601.  
  602.     pvm_pkstr( str );
  603.     pvm_pkint( &num, 1, 1 );
  604.  
  605.     /* Insert Into Class */
  606.  
  607.     cc = pvm_putinfo( class, pvm_getsbuf(), flags );
  608.  
  609.     if ( cc < 0 )
  610.         pvm_perror( "Inserting Message" );
  611.  
  612.     else
  613.     {
  614.         printf( "Inserted Message Into \"%s\" at index=%d:",
  615.             class, cc );
  616.         dump_flags( flags );
  617.         printf( "\n" );
  618.         printf( "\t\"%s\"\n", str );
  619.         printf( "\t0x%x\n", num );
  620.     }
  621.  
  622.     pvm_freebuf( pvm_getsbuf() );
  623.  
  624.     return( cc );
  625. }
  626.  
  627.  
  628. int
  629. check_msg( class, index, flags, str, num, do_unpack )
  630. char *class;
  631. int index;
  632. int flags;
  633. char *str;
  634. int *num;
  635. int do_unpack;
  636. {
  637.     int cc;
  638.  
  639.     /* Retrieve Message */
  640.  
  641.     cc = pvm_recvinfo( class, index, flags );
  642.  
  643.     if ( cc < 0 )
  644.     {
  645.         if ( do_unpack )
  646.             pvm_perror( "Retrieving Message" );
  647.     }
  648.  
  649.     else
  650.     {
  651.         if ( do_unpack )
  652.         {
  653.             pvm_upkstr( str );
  654.             pvm_upkint( num, 1, 1 );
  655.         }
  656.  
  657.         printf( "Retrieved Message From \"%s\" at index=%d:",
  658.             class, index );
  659.         dump_flags( flags );
  660.         printf( "\n" );
  661.  
  662.         if ( do_unpack )
  663.         {
  664.             printf( "\t\"%s\"\n", str );
  665.             printf( "\t0x%x\n", *num );
  666.         }
  667.  
  668.         else
  669.             printf( "\t(not unpacked)\n" );
  670.     }
  671.  
  672.     return( cc );
  673. }
  674.  
  675.  
  676. int usage()
  677. {
  678.     printf( "\n" );
  679.     printf( "usage:  mbox [pers] [favail] [owrit] [minst] [rddel]\n" );
  680.     printf( "\t[sleep[=<secs>]] [name=<class_name>]\n" );
  681.     printf( "\t[query [<index>]] [wait] [noreset] [noexit]\n" );
  682.     printf( "\t[info [<pattern>]] [delete [<index>]]\n" );
  683.     printf( "\t[help]\n" );
  684.     printf( "\n" );
  685.  
  686.     exit( 0 );
  687. }
  688.  
  689.